// 后台服务脚本
class BackgroundService {
    constructor() {
        this.init();
    }

    init() {
        this.createContextMenus();
        this.bindEvents();
    }

    // 创建右键菜单
    createContextMenus() {
        // 移除现有菜单
        chrome.contextMenus.removeAll(() => {
            // 主菜单
            chrome.contextMenus.create({
                id: 'devToolbox',
                title: '开发工具箱',
                contexts: ['selection', 'page']
            });

            // JSON格式化菜单
            chrome.contextMenus.create({
                id: 'formatJSON',
                parentId: 'devToolbox',
                title: 'JSON格式化',
                contexts: ['selection']
            });

            // XML格式化菜单
            chrome.contextMenus.create({
                id: 'formatXML',
                parentId: 'devToolbox',
                title: 'XML格式化',
                contexts: ['selection']
            });

            // URL编码菜单
            chrome.contextMenus.create({
                id: 'encodeURL',
                parentId: 'devToolbox',
                title: 'URL编码',
                contexts: ['selection']
            });

            // URL解码菜单
            chrome.contextMenus.create({
                id: 'decodeURL',
                parentId: 'devToolbox',
                title: 'URL解码',
                contexts: ['selection']
            });

            // Base64编码菜单
            chrome.contextMenus.create({
                id: 'encodeBase64',
                parentId: 'devToolbox',
                title: 'Base64编码',
                contexts: ['selection']
            });

            // Base64解码菜单
            chrome.contextMenus.create({
                id: 'decodeBase64',
                parentId: 'devToolbox',
                title: 'Base64解码',
                contexts: ['selection']
            });

            // MD5加密菜单
            chrome.contextMenus.create({
                id: 'generateMD5',
                parentId: 'devToolbox',
                title: 'MD5加密',
                contexts: ['selection']
            });
        });
    }

    // 绑定事件
    bindEvents() {
        // 右键菜单点击事件
        chrome.contextMenus.onClicked.addListener((info, tab) => {
            this.handleContextMenuClick(info, tab);
        });

        // 插件安装事件
        chrome.runtime.onInstalled.addListener((details) => {
            if (details.reason === 'install') {
                console.log('开发工具箱插件已安装');
            } else if (details.reason === 'update') {
                console.log('开发工具箱插件已更新');
            }
        });

        // 消息监听
        chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
            this.handleMessage(request, sender, sendResponse);
            return true; // 保持消息通道开放
        });
    }

    // 处理右键菜单点击
    async handleContextMenuClick(info, tab) {
        const selectedText = info.selectionText;
        if (!selectedText) {
            this.showNotification('请先选择文本', 'error');
            return;
        }

        let result = '';
        let title = '';

        try {
            switch (info.menuItemId) {
                case 'formatJSON':
                    result = this.formatJSON(selectedText);
                    title = 'JSON格式化结果';
                    break;
                case 'formatXML':
                    result = this.formatXML(selectedText);
                    title = 'XML格式化结果';
                    break;
                case 'encodeURL':
                    result = encodeURIComponent(selectedText);
                    title = 'URL编码结果';
                    break;
                case 'decodeURL':
                    result = decodeURIComponent(selectedText);
                    title = 'URL解码结果';
                    break;
                case 'encodeBase64':
                    result = btoa(unescape(encodeURIComponent(selectedText)));
                    title = 'Base64编码结果';
                    break;
                case 'decodeBase64':
                    result = decodeURIComponent(escape(atob(selectedText)));
                    title = 'Base64解码结果';
                    break;
                case 'generateMD5':
                    result = this.md5(selectedText);
                    title = 'MD5加密结果';
                    break;
                default:
                    return;
            }

            // 将结果复制到剪贴板
            await this.copyToClipboard(result);
            this.showNotification(`${title}已复制到剪贴板`, 'success');

            // 发送结果到内容脚本
            chrome.tabs.sendMessage(tab.id, {
                action: 'showResult',
                title: title,
                result: result
            });

        } catch (error) {
            this.showNotification(`处理失败: ${error.message}`, 'error');
        }
    }

    // 处理消息
    handleMessage(request, sender, sendResponse) {
        switch (request.action) {
            case 'copyToClipboard':
                this.copyToClipboard(request.text)
                    .then(() => sendResponse({ success: true }))
                    .catch(error => sendResponse({ success: false, error: error.message }));
                break;
            case 'showNotification':
                this.showNotification(request.message, request.type);
                sendResponse({ success: true });
                break;
            default:
                sendResponse({ success: false, error: 'Unknown action' });
        }
    }

    // JSON格式化
    formatJSON(jsonString) {
        const parsed = JSON.parse(jsonString);
        return JSON.stringify(parsed, null, 2);
    }

    // XML格式化
    formatXML(xmlString) {
        const PADDING = ' '.repeat(2);
        const reg = /(>)(<)(\/*)/g;
        let pad = 0;

        xmlString = xmlString.replace(reg, '$1\r\n$2$3');

        return xmlString.split('\r\n').map((node) => {
            let indent = 0;
            if (node.match(/.+<\/\w[^>]*>$/)) {
                indent = 0;
            } else if (node.match(/^<\/\w/) && pad > 0) {
                pad -= 1;
            } else if (node.match(/^<\w[^>]*[^/]>.*$/)) {
                indent = 1;
            } else {
                indent = 0;
            }

            const padding = PADDING.repeat(pad);
            pad += indent;

            return padding + node;
        }).join('\r\n');
    }

    // MD5加密（简化版）
    md5(string) {
        // 这里使用一个简化的MD5实现
        // 在实际应用中，建议使用更完整的MD5库
        function md5cycle(x, k) {
            var a = x[0], b = x[1], c = x[2], d = x[3];
            a = ff(a, b, c, d, k[0], 7, -680876936);
            d = ff(d, a, b, c, k[1], 12, -389564586);
            c = ff(c, d, a, b, k[2], 17, 606105819);
            b = ff(b, c, d, a, k[3], 22, -1044525330);
            a = ff(a, b, c, d, k[4], 7, -176418897);
            d = ff(d, a, b, c, k[5], 12, 1200080426);
            c = ff(c, d, a, b, k[6], 17, -1473231341);
            b = ff(b, c, d, a, k[7], 22, -45705983);
            a = ff(a, b, c, d, k[8], 7, 1770035416);
            d = ff(d, a, b, c, k[9], 12, -1958414417);
            c = ff(c, d, a, b, k[10], 17, -42063);
            b = ff(b, c, d, a, k[11], 22, -1990404162);
            a = ff(a, b, c, d, k[12], 7, 1804603682);
            d = ff(d, a, b, c, k[13], 12, -40341101);
            c = ff(c, d, a, b, k[14], 17, -1502002290);
            b = ff(b, c, d, a, k[15], 22, 1236535329);
            a = gg(a, b, c, d, k[1], 5, -165796510);
            d = gg(d, a, b, c, k[6], 9, -1069501632);
            c = gg(c, d, a, b, k[11], 14, 643717713);
            b = gg(b, c, d, a, k[0], 20, -373897302);
            a = gg(a, b, c, d, k[5], 5, -701558691);
            d = gg(d, a, b, c, k[10], 9, 38016083);
            c = gg(c, d, a, b, k[15], 14, -660478335);
            b = gg(b, c, d, a, k[4], 20, -405537848);
            a = gg(a, b, c, d, k[9], 5, 568446438);
            d = gg(d, a, b, c, k[14], 9, -1019803690);
            c = gg(c, d, a, b, k[3], 14, -187363961);
            b = gg(b, c, d, a, k[8], 20, 1163531501);
            a = gg(a, b, c, d, k[13], 5, -1444681467);
            d = gg(d, a, b, c, k[2], 9, -51403784);
            c = gg(c, d, a, b, k[7], 14, 1735328473);
            b = gg(b, c, d, a, k[12], 20, -1926607734);
            a = hh(a, b, c, d, k[5], 4, -378558);
            d = hh(d, a, b, c, k[8], 11, -2022574463);
            c = hh(c, d, a, b, k[11], 16, 1839030562);
            b = hh(b, c, d, a, k[14], 23, -35309556);
            a = hh(a, b, c, d, k[1], 4, -1530992060);
            d = hh(d, a, b, c, k[4], 11, 1272893353);
            c = hh(c, d, a, b, k[7], 16, -155497632);
            b = hh(b, c, d, a, k[10], 23, -1094730640);
            a = hh(a, b, c, d, k[13], 4, 681279174);
            d = hh(d, a, b, c, k[0], 11, -358537222);
            c = hh(c, d, a, b, k[3], 16, -722521979);
            b = hh(b, c, d, a, k[6], 23, 76029189);
            a = hh(a, b, c, d, k[9], 4, -640364487);
            d = hh(d, a, b, c, k[12], 11, -421815835);
            c = hh(c, d, a, b, k[15], 16, 530742520);
            b = hh(b, c, d, a, k[2], 23, -995338651);
            a = ii(a, b, c, d, k[0], 6, -198630844);
            d = ii(d, a, b, c, k[7], 10, 1126891415);
            c = ii(c, d, a, b, k[14], 15, -1416354905);
            b = ii(b, c, d, a, k[5], 21, -57434055);
            a = ii(a, b, c, d, k[12], 6, 1700485571);
            d = ii(d, a, b, c, k[3], 10, -1894986606);
            c = ii(c, d, a, b, k[10], 15, -1051523);
            b = ii(b, c, d, a, k[1], 21, -2054922799);
            a = ii(a, b, c, d, k[8], 6, 1873313359);
            d = ii(d, a, b, c, k[15], 10, -30611744);
            c = ii(c, d, a, b, k[6], 15, -1560198380);
            b = ii(b, c, d, a, k[13], 21, 1309151649);
            a = ii(a, b, c, d, k[4], 6, -145523070);
            d = ii(d, a, b, c, k[11], 10, -1120210379);
            c = ii(c, d, a, b, k[2], 15, 718787259);
            b = ii(b, c, d, a, k[9], 21, -343485551);
            x[0] = add32(a, x[0]);
            x[1] = add32(b, x[1]);
            x[2] = add32(c, x[2]);
            x[3] = add32(d, x[3]);
        }

        function cmn(q, a, b, x, s, t) {
            a = add32(add32(a, q), add32(x, t));
            return add32((a << s) | (a >>> (32 - s)), b);
        }

        function ff(a, b, c, d, x, s, t) {
            return cmn((b & c) | ((~b) & d), a, b, x, s, t);
        }

        function gg(a, b, c, d, x, s, t) {
            return cmn((b & d) | (c & (~d)), a, b, x, s, t);
        }

        function hh(a, b, c, d, x, s, t) {
            return cmn(b ^ c ^ d, a, b, x, s, t);
        }

        function ii(a, b, c, d, x, s, t) {
            return cmn(c ^ (b | (~d)), a, b, x, s, t);
        }

        function md51(s) {
            var n = s.length,
                state = [1732584193, -271733879, -1732584194, 271733878], i;
            for (i = 64; i <= s.length; i += 64) {
                md5cycle(state, md5blk(s.substring(i - 64, i)));
            }
            s = s.substring(i - 64);
            var tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
            for (i = 0; i < s.length; i++)
                tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
            tail[i >> 2] |= 0x80 << ((i % 4) << 3);
            if (i > 55) {
                md5cycle(state, tail);
                for (i = 0; i < 16; i++) tail[i] = 0;
            }
            tail[14] = n * 8;
            md5cycle(state, tail);
            return state;
        }

        function md5blk(s) {
            var md5blks = [], i;
            for (i = 0; i < 64; i += 4) {
                md5blks[i >> 2] = s.charCodeAt(i)
                    + (s.charCodeAt(i + 1) << 8)
                    + (s.charCodeAt(i + 2) << 16)
                    + (s.charCodeAt(i + 3) << 24);
            }
            return md5blks;
        }

        var hex_chr = '0123456789abcdef'.split('');

        function rhex(n) {
            var s = '', j = 0;
            for (; j < 4; j++)
                s += hex_chr[(n >> (j * 8 + 4)) & 0x0F]
                    + hex_chr[(n >> (j * 8)) & 0x0F];
            return s;
        }

        function hex(x) {
            for (var i = 0; i < x.length; i++)
                x[i] = rhex(x[i]);
            return x.join('');
        }

        function add32(a, b) {
            return (a + b) & 0xFFFFFFFF;
        }

        return hex(md51(string));
    }

    // 复制到剪贴板
    async copyToClipboard(text) {
        try {
            await navigator.clipboard.writeText(text);
        } catch (error) {
            // 降级方案：使用execCommand
            const textarea = document.createElement('textarea');
            textarea.value = text;
            document.body.appendChild(textarea);
            textarea.select();
            document.execCommand('copy');
            document.body.removeChild(textarea);
        }
    }

    // 显示通知
    showNotification(message, type = 'info') {
        const iconUrl = type === 'error' ? 'icons/icon32.png' : 'icons/icon32.png';
        
        chrome.notifications.create({
            type: 'basic',
            iconUrl: iconUrl,
            title: '开发工具箱',
            message: message
        });
    }
}

// 初始化后台服务
new BackgroundService();